// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/cloud/cron_script/cronscriptpb/service.proto

package cronscriptpb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type CronScript struct {
	ID         *uuidpb.UUID   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrgID      *uuidpb.UUID   `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	Script     string         `protobuf:"bytes,3,opt,name=script,proto3" json:"script,omitempty"`
	CronExpr   string         `protobuf:"bytes,4,opt,name=cron_expr,json=cronExpr,proto3" json:"cron_expr,omitempty"`
	ClusterIDs []*uuidpb.UUID `protobuf:"bytes,5,rep,name=cluster_ids,json=clusterIds,proto3" json:"cluster_ids,omitempty"`
	Configs    string         `protobuf:"bytes,6,opt,name=configs,proto3" json:"configs,omitempty"`
	Token      string         `protobuf:"bytes,7,opt,name=token,proto3" json:"token,omitempty"`
	Enabled    bool           `protobuf:"varint,8,opt,name=enabled,proto3" json:"enabled,omitempty"`
	FrequencyS int64          `protobuf:"varint,9,opt,name=frequency_s,json=frequencyS,proto3" json:"frequency_s,omitempty"`
}

func (m *CronScript) Reset()      { *m = CronScript{} }
func (*CronScript) ProtoMessage() {}
func (*CronScript) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{0}
}
func (m *CronScript) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CronScript) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CronScript.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CronScript) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CronScript.Merge(m, src)
}
func (m *CronScript) XXX_Size() int {
	return m.Size()
}
func (m *CronScript) XXX_DiscardUnknown() {
	xxx_messageInfo_CronScript.DiscardUnknown(m)
}

var xxx_messageInfo_CronScript proto.InternalMessageInfo

func (m *CronScript) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *CronScript) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *CronScript) GetScript() string {
	if m != nil {
		return m.Script
	}
	return ""
}

func (m *CronScript) GetCronExpr() string {
	if m != nil {
		return m.CronExpr
	}
	return ""
}

func (m *CronScript) GetClusterIDs() []*uuidpb.UUID {
	if m != nil {
		return m.ClusterIDs
	}
	return nil
}

func (m *CronScript) GetConfigs() string {
	if m != nil {
		return m.Configs
	}
	return ""
}

func (m *CronScript) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *CronScript) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *CronScript) GetFrequencyS() int64 {
	if m != nil {
		return m.FrequencyS
	}
	return 0
}

type GetScriptRequest struct {
	ID    *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrgID *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

func (m *GetScriptRequest) Reset()      { *m = GetScriptRequest{} }
func (*GetScriptRequest) ProtoMessage() {}
func (*GetScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{1}
}
func (m *GetScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptRequest.Merge(m, src)
}
func (m *GetScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptRequest proto.InternalMessageInfo

func (m *GetScriptRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *GetScriptRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type GetScriptResponse struct {
	Script *CronScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"`
}

func (m *GetScriptResponse) Reset()      { *m = GetScriptResponse{} }
func (*GetScriptResponse) ProtoMessage() {}
func (*GetScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{2}
}
func (m *GetScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptResponse.Merge(m, src)
}
func (m *GetScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptResponse proto.InternalMessageInfo

func (m *GetScriptResponse) GetScript() *CronScript {
	if m != nil {
		return m.Script
	}
	return nil
}

type GetScriptsRequest struct {
	IDs   []*uuidpb.UUID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	OrgID *uuidpb.UUID   `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

func (m *GetScriptsRequest) Reset()      { *m = GetScriptsRequest{} }
func (*GetScriptsRequest) ProtoMessage() {}
func (*GetScriptsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{3}
}
func (m *GetScriptsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptsRequest.Merge(m, src)
}
func (m *GetScriptsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptsRequest proto.InternalMessageInfo

func (m *GetScriptsRequest) GetIDs() []*uuidpb.UUID {
	if m != nil {
		return m.IDs
	}
	return nil
}

func (m *GetScriptsRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type GetScriptsResponse struct {
	Scripts []*CronScript `protobuf:"bytes,1,rep,name=scripts,proto3" json:"scripts,omitempty"`
}

func (m *GetScriptsResponse) Reset()      { *m = GetScriptsResponse{} }
func (*GetScriptsResponse) ProtoMessage() {}
func (*GetScriptsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{4}
}
func (m *GetScriptsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetScriptsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetScriptsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetScriptsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetScriptsResponse.Merge(m, src)
}
func (m *GetScriptsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetScriptsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetScriptsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetScriptsResponse proto.InternalMessageInfo

func (m *GetScriptsResponse) GetScripts() []*CronScript {
	if m != nil {
		return m.Scripts
	}
	return nil
}

type CreateScriptRequest struct {
	Script     string         `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"`
	CronExpr   string         `protobuf:"bytes,2,opt,name=cron_expr,json=cronExpr,proto3" json:"cron_expr,omitempty"`
	ClusterIDs []*uuidpb.UUID `protobuf:"bytes,3,rep,name=cluster_ids,json=clusterIds,proto3" json:"cluster_ids,omitempty"`
	Configs    string         `protobuf:"bytes,4,opt,name=configs,proto3" json:"configs,omitempty"`
	Token      string         `protobuf:"bytes,5,opt,name=token,proto3" json:"token,omitempty"`
	FrequencyS int64          `protobuf:"varint,6,opt,name=frequency_s,json=frequencyS,proto3" json:"frequency_s,omitempty"`
	Disabled   bool           `protobuf:"varint,7,opt,name=disabled,proto3" json:"disabled,omitempty"`
	OrgID      *uuidpb.UUID   `protobuf:"bytes,8,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

func (m *CreateScriptRequest) Reset()      { *m = CreateScriptRequest{} }
func (*CreateScriptRequest) ProtoMessage() {}
func (*CreateScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{5}
}
func (m *CreateScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateScriptRequest.Merge(m, src)
}
func (m *CreateScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateScriptRequest proto.InternalMessageInfo

func (m *CreateScriptRequest) GetScript() string {
	if m != nil {
		return m.Script
	}
	return ""
}

func (m *CreateScriptRequest) GetCronExpr() string {
	if m != nil {
		return m.CronExpr
	}
	return ""
}

func (m *CreateScriptRequest) GetClusterIDs() []*uuidpb.UUID {
	if m != nil {
		return m.ClusterIDs
	}
	return nil
}

func (m *CreateScriptRequest) GetConfigs() string {
	if m != nil {
		return m.Configs
	}
	return ""
}

func (m *CreateScriptRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *CreateScriptRequest) GetFrequencyS() int64 {
	if m != nil {
		return m.FrequencyS
	}
	return 0
}

func (m *CreateScriptRequest) GetDisabled() bool {
	if m != nil {
		return m.Disabled
	}
	return false
}

func (m *CreateScriptRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type CreateScriptResponse struct {
	ID *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *CreateScriptResponse) Reset()      { *m = CreateScriptResponse{} }
func (*CreateScriptResponse) ProtoMessage() {}
func (*CreateScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{6}
}
func (m *CreateScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateScriptResponse.Merge(m, src)
}
func (m *CreateScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *CreateScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateScriptResponse proto.InternalMessageInfo

func (m *CreateScriptResponse) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

type UpdateScriptRequest struct {
	Script         *types.StringValue `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"`
	CronExpression *types.StringValue `protobuf:"bytes,2,opt,name=cron_expression,json=cronExpression,proto3" json:"cron_expression,omitempty"`
	ClusterIDs     *ClusterIDs        `protobuf:"bytes,3,opt,name=cluster_ids,json=clusterIds,proto3" json:"cluster_ids,omitempty"`
	Configs        *types.StringValue `protobuf:"bytes,4,opt,name=configs,proto3" json:"configs,omitempty"`
	Enabled        *types.BoolValue   `protobuf:"bytes,5,opt,name=enabled,proto3" json:"enabled,omitempty"`
	FrequencyS     *types.Int64Value  `protobuf:"bytes,6,opt,name=frequency_s,json=frequencyS,proto3" json:"frequency_s,omitempty"`
	ScriptId       *uuidpb.UUID       `protobuf:"bytes,7,opt,name=script_id,json=scriptId,proto3" json:"script_id,omitempty"`
	OrgID          *uuidpb.UUID       `protobuf:"bytes,8,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

func (m *UpdateScriptRequest) Reset()      { *m = UpdateScriptRequest{} }
func (*UpdateScriptRequest) ProtoMessage() {}
func (*UpdateScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{7}
}
func (m *UpdateScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateScriptRequest.Merge(m, src)
}
func (m *UpdateScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateScriptRequest proto.InternalMessageInfo

func (m *UpdateScriptRequest) GetScript() *types.StringValue {
	if m != nil {
		return m.Script
	}
	return nil
}

func (m *UpdateScriptRequest) GetCronExpression() *types.StringValue {
	if m != nil {
		return m.CronExpression
	}
	return nil
}

func (m *UpdateScriptRequest) GetClusterIDs() *ClusterIDs {
	if m != nil {
		return m.ClusterIDs
	}
	return nil
}

func (m *UpdateScriptRequest) GetConfigs() *types.StringValue {
	if m != nil {
		return m.Configs
	}
	return nil
}

func (m *UpdateScriptRequest) GetEnabled() *types.BoolValue {
	if m != nil {
		return m.Enabled
	}
	return nil
}

func (m *UpdateScriptRequest) GetFrequencyS() *types.Int64Value {
	if m != nil {
		return m.FrequencyS
	}
	return nil
}

func (m *UpdateScriptRequest) GetScriptId() *uuidpb.UUID {
	if m != nil {
		return m.ScriptId
	}
	return nil
}

func (m *UpdateScriptRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type ClusterIDs struct {
	Value []*uuidpb.UUID `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
}

func (m *ClusterIDs) Reset()      { *m = ClusterIDs{} }
func (*ClusterIDs) ProtoMessage() {}
func (*ClusterIDs) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{8}
}
func (m *ClusterIDs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterIDs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClusterIDs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ClusterIDs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterIDs.Merge(m, src)
}
func (m *ClusterIDs) XXX_Size() int {
	return m.Size()
}
func (m *ClusterIDs) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterIDs.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterIDs proto.InternalMessageInfo

func (m *ClusterIDs) GetValue() []*uuidpb.UUID {
	if m != nil {
		return m.Value
	}
	return nil
}

type UpdateScriptResponse struct {
}

func (m *UpdateScriptResponse) Reset()      { *m = UpdateScriptResponse{} }
func (*UpdateScriptResponse) ProtoMessage() {}
func (*UpdateScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{9}
}
func (m *UpdateScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateScriptResponse.Merge(m, src)
}
func (m *UpdateScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *UpdateScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateScriptResponse proto.InternalMessageInfo

type DeleteScriptRequest struct {
	ID    *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrgID *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

func (m *DeleteScriptRequest) Reset()      { *m = DeleteScriptRequest{} }
func (*DeleteScriptRequest) ProtoMessage() {}
func (*DeleteScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{10}
}
func (m *DeleteScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteScriptRequest.Merge(m, src)
}
func (m *DeleteScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteScriptRequest proto.InternalMessageInfo

func (m *DeleteScriptRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *DeleteScriptRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type DeleteScriptResponse struct {
}

func (m *DeleteScriptResponse) Reset()      { *m = DeleteScriptResponse{} }
func (*DeleteScriptResponse) ProtoMessage() {}
func (*DeleteScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9421d06c83b7b792, []int{11}
}
func (m *DeleteScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteScriptResponse.Merge(m, src)
}
func (m *DeleteScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteScriptResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*CronScript)(nil), "px.services.internal.CronScript")
	proto.RegisterType((*GetScriptRequest)(nil), "px.services.internal.GetScriptRequest")
	proto.RegisterType((*GetScriptResponse)(nil), "px.services.internal.GetScriptResponse")
	proto.RegisterType((*GetScriptsRequest)(nil), "px.services.internal.GetScriptsRequest")
	proto.RegisterType((*GetScriptsResponse)(nil), "px.services.internal.GetScriptsResponse")
	proto.RegisterType((*CreateScriptRequest)(nil), "px.services.internal.CreateScriptRequest")
	proto.RegisterType((*CreateScriptResponse)(nil), "px.services.internal.CreateScriptResponse")
	proto.RegisterType((*UpdateScriptRequest)(nil), "px.services.internal.UpdateScriptRequest")
	proto.RegisterType((*ClusterIDs)(nil), "px.services.internal.ClusterIDs")
	proto.RegisterType((*UpdateScriptResponse)(nil), "px.services.internal.UpdateScriptResponse")
	proto.RegisterType((*DeleteScriptRequest)(nil), "px.services.internal.DeleteScriptRequest")
	proto.RegisterType((*DeleteScriptResponse)(nil), "px.services.internal.DeleteScriptResponse")
}

func init() {
	proto.RegisterFile("src/cloud/cron_script/cronscriptpb/service.proto", fileDescriptor_9421d06c83b7b792)
}

var fileDescriptor_9421d06c83b7b792 = []byte{
	// 844 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4d, 0x6f, 0xe3, 0x54,
	0x14, 0x8d, 0x93, 0xe6, 0xeb, 0x66, 0x34, 0xc3, 0xbc, 0x46, 0x91, 0x95, 0x41, 0x4e, 0x64, 0x09,
	0x26, 0x8c, 0xc0, 0x81, 0x4e, 0x35, 0x42, 0x08, 0x09, 0x94, 0x66, 0x84, 0xbc, 0x40, 0x80, 0xa3,
	0xb2, 0x40, 0x48, 0x51, 0x62, 0xbf, 0x1a, 0x0b, 0xe3, 0xe7, 0xbe, 0x67, 0x97, 0xb0, 0x63, 0xc7,
	0x96, 0x9f, 0xc1, 0x82, 0x1f, 0x82, 0x58, 0x75, 0xd9, 0x55, 0x44, 0xdd, 0x0d, 0xcb, 0x8a, 0x5f,
	0x80, 0xec, 0x67, 0x3b, 0x4e, 0x62, 0x27, 0x55, 0x47, 0x5d, 0xc5, 0xf7, 0xf9, 0x5e, 0x9f, 0xeb,
	0x73, 0x8e, 0x8f, 0x02, 0x1f, 0x32, 0xaa, 0x0f, 0x75, 0x9b, 0xf8, 0xc6, 0x50, 0xa7, 0xc4, 0x99,
	0x32, 0x9d, 0x5a, 0xae, 0x17, 0x5d, 0xf3, 0x4b, 0x77, 0x3e, 0x64, 0x98, 0x5e, 0x58, 0x3a, 0x56,
	0x5c, 0x4a, 0x3c, 0x82, 0xda, 0xee, 0x42, 0x89, 0x4f, 0x98, 0x62, 0x39, 0x1e, 0xa6, 0xce, 0xcc,
	0xee, 0x7e, 0x60, 0x5a, 0xde, 0x0f, 0xfe, 0x5c, 0xd1, 0xc9, 0x4f, 0x43, 0x93, 0x98, 0x64, 0x18,
	0x35, 0xcf, 0xfd, 0xb3, 0xa8, 0x8a, 0x8a, 0xe8, 0x8a, 0x3f, 0xa4, 0x2b, 0x99, 0x84, 0x98, 0x36,
	0x5e, 0x75, 0xfd, 0x4c, 0x67, 0xae, 0x8b, 0x29, 0x8b, 0xef, 0xf7, 0xc2, 0xb5, 0x66, 0xae, 0xc5,
	0x1b, 0x86, 0xbe, 0x6f, 0x19, 0xee, 0x3c, 0xfa, 0xe1, 0x0d, 0xf2, 0xdf, 0x65, 0x80, 0x13, 0x4a,
	0x9c, 0x49, 0xb4, 0x24, 0x7a, 0x0e, 0x65, 0xcb, 0x10, 0x85, 0xbe, 0x30, 0x68, 0x1d, 0x3d, 0x51,
	0xdc, 0x85, 0xc2, 0x27, 0x94, 0xd3, 0x53, 0x75, 0x3c, 0xaa, 0x05, 0xcb, 0x5e, 0x59, 0x1d, 0x6b,
	0x65, 0xcb, 0x40, 0x1f, 0x41, 0x8d, 0x50, 0x73, 0x6a, 0x19, 0x62, 0x39, 0xbf, 0xb9, 0x19, 0x2c,
	0x7b, 0xd5, 0xaf, 0xa8, 0xa9, 0x8e, 0xb5, 0x2a, 0xa1, 0xa6, 0x6a, 0xa0, 0x0e, 0xd4, 0x38, 0x15,
	0x62, 0xa5, 0x2f, 0x0c, 0x9a, 0x5a, 0x5c, 0xa1, 0x67, 0xd0, 0x8c, 0x28, 0xc3, 0x0b, 0x97, 0x8a,
	0x07, 0xd1, 0xad, 0x46, 0x78, 0xf0, 0x7a, 0xe1, 0x52, 0xf4, 0x39, 0xb4, 0x74, 0xdb, 0x67, 0x1e,
	0xa6, 0x53, 0xcb, 0x60, 0x62, 0xb5, 0x5f, 0xc9, 0x03, 0x7b, 0x1c, 0x2c, 0x7b, 0x70, 0xc2, 0xfb,
	0xd4, 0x31, 0xd3, 0x20, 0x9e, 0x51, 0x0d, 0x86, 0x44, 0xa8, 0xeb, 0xc4, 0x39, 0xb3, 0x4c, 0x26,
	0xd6, 0xa2, 0x87, 0x27, 0x25, 0x6a, 0x43, 0xd5, 0x23, 0x3f, 0x62, 0x47, 0xac, 0x47, 0xe7, 0xbc,
	0x08, 0xfb, 0xb1, 0x33, 0x9b, 0xdb, 0xd8, 0x10, 0x1b, 0x7d, 0x61, 0xd0, 0xd0, 0x92, 0x12, 0xf5,
	0xa0, 0x75, 0x46, 0xf1, 0xb9, 0x8f, 0x1d, 0xfd, 0x97, 0x29, 0x13, 0x9b, 0x7d, 0x61, 0x50, 0xd1,
	0x20, 0x3d, 0x9a, 0xc8, 0x0e, 0xbc, 0xf5, 0x05, 0xf6, 0x38, 0x95, 0x5a, 0x78, 0xca, 0x1e, 0x94,
	0x51, 0xf9, 0x4b, 0x78, 0x9a, 0xc1, 0x63, 0x2e, 0x71, 0x18, 0x46, 0x1f, 0xa7, 0x34, 0x73, 0xd0,
	0xbe, 0x92, 0x67, 0x34, 0x65, 0x25, 0x7a, 0x22, 0x84, 0x4c, 0x33, 0x8f, 0x63, 0xc9, 0xfe, 0x2f,
	0xa0, 0x12, 0x12, 0x2f, 0xe4, 0x13, 0x5f, 0x0f, 0x96, 0xbd, 0x4a, 0xc8, 0x78, 0xd8, 0x74, 0x9f,
	0x57, 0xf8, 0x1a, 0x50, 0x16, 0x33, 0x7e, 0x87, 0x4f, 0xa0, 0xce, 0x77, 0x4a, 0x80, 0xf7, 0xbf,
	0x44, 0x32, 0x20, 0xff, 0x59, 0x86, 0xc3, 0x13, 0x8a, 0x67, 0x1e, 0x5e, 0x17, 0xa2, 0xb3, 0xc6,
	0x4b, 0x81, 0xfd, 0xca, 0xbb, 0xed, 0x57, 0x79, 0x23, 0xfb, 0x1d, 0x14, 0xd8, 0xaf, 0x9a, 0xb5,
	0xdf, 0x86, 0xc9, 0x6a, 0x9b, 0x26, 0x43, 0x5d, 0x68, 0x18, 0x16, 0xe3, 0x06, 0xad, 0x47, 0x06,
	0x4d, 0xeb, 0x8c, 0x00, 0x8d, 0xbb, 0x0a, 0xf0, 0x19, 0xb4, 0xd7, 0xd9, 0x8a, 0x25, 0xb8, 0xab,
	0x6f, 0xe5, 0xff, 0x2a, 0x70, 0x78, 0xea, 0x1a, 0x5b, 0x7c, 0x1f, 0x6f, 0xf8, 0xf0, 0x6d, 0x85,
	0x67, 0x95, 0x92, 0x64, 0x95, 0x32, 0xf1, 0xa8, 0xe5, 0x98, 0xdf, 0xce, 0x6c, 0x1f, 0xa7, 0x6a,
	0xbc, 0x86, 0x27, 0xa9, 0x1a, 0x98, 0x31, 0x8b, 0x38, 0xb1, 0x97, 0x76, 0x8f, 0x3f, 0x4e, 0x14,
	0xe3, 0x33, 0xe8, 0x9b, 0x4d, 0xdd, 0x76, 0x7d, 0x09, 0xa9, 0x70, 0x3b, 0x85, 0x7c, 0xb5, 0x2e,
	0xe4, 0xbe, 0x8d, 0x52, 0x99, 0x8f, 0x57, 0x79, 0x52, 0x8d, 0xe6, 0xba, 0x5b, 0x73, 0x23, 0x42,
	0xec, 0x78, 0x2a, 0xc9, 0x9a, 0x4f, 0xb7, 0x6d, 0xd0, 0x3a, 0x7a, 0xb6, 0x35, 0xa9, 0x3a, 0xde,
	0xab, 0x63, 0x3e, 0x9a, 0xf5, 0xc8, 0xfb, 0xd0, 0xe4, 0x7c, 0x86, 0x56, 0xa8, 0xe7, 0x6a, 0xa8,
	0x35, 0x78, 0x87, 0x7a, 0x2f, 0xd7, 0xbc, 0x84, 0x0c, 0x4d, 0xe8, 0x1d, 0xa8, 0x5e, 0x84, 0x3b,
	0x14, 0xa4, 0x84, 0xc6, 0xef, 0xca, 0x1d, 0x68, 0xaf, 0x1b, 0x85, 0x5b, 0x4d, 0x3e, 0x87, 0xc3,
	0x31, 0xb6, 0xf1, 0xa6, 0x81, 0x1e, 0x32, 0x39, 0x3b, 0xd0, 0x5e, 0x87, 0xe4, 0xab, 0x1c, 0xfd,
	0x76, 0x00, 0x4f, 0x57, 0xa1, 0x32, 0xe1, 0x5e, 0x41, 0xdf, 0x43, 0x33, 0x0d, 0x29, 0xf4, 0x6e,
	0xbe, 0x8b, 0x36, 0x83, 0xbf, 0xfb, 0x7c, 0x6f, 0x5f, 0xfc, 0xa5, 0x4d, 0x01, 0x56, 0x11, 0x88,
	0xf6, 0x8d, 0x25, 0xc1, 0xdc, 0x1d, 0xec, 0x6f, 0x8c, 0x01, 0x30, 0x3c, 0xca, 0x7e, 0xe2, 0xe8,
	0xbd, 0xa2, 0x30, 0xdd, 0x0a, 0xcd, 0xee, 0x8b, 0xbb, 0xb4, 0xae, 0x60, 0xb2, 0xf2, 0x16, 0xc1,
	0xe4, 0x64, 0x45, 0x11, 0x4c, 0x9e, 0x5b, 0x42, 0x98, 0xac, 0x74, 0x45, 0x30, 0x39, 0x8e, 0x2a,
	0x82, 0xc9, 0x73, 0xc2, 0x68, 0x74, 0x79, 0x2d, 0x95, 0xae, 0xae, 0xa5, 0xd2, 0xed, 0xb5, 0x24,
	0xfc, 0x1a, 0x48, 0xc2, 0x1f, 0x81, 0x24, 0xfc, 0x15, 0x48, 0xc2, 0x65, 0x20, 0x09, 0xff, 0x04,
	0x92, 0xf0, 0x6f, 0x20, 0x95, 0x6e, 0x03, 0x49, 0xf8, 0xfd, 0x46, 0x2a, 0x5d, 0xde, 0x48, 0xa5,
	0xab, 0x1b, 0xa9, 0xf4, 0xdd, 0xa3, 0xec, 0x1f, 0xbe, 0x79, 0x2d, 0xfa, 0x4e, 0x5f, 0xfe, 0x1f,
	0x00, 0x00, 0xff, 0xff, 0xd5, 0x1a, 0x10, 0xf8, 0x1d, 0x0a, 0x00, 0x00,
}

func (this *CronScript) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CronScript)
	if !ok {
		that2, ok := that.(CronScript)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if this.Script != that1.Script {
		return false
	}
	if this.CronExpr != that1.CronExpr {
		return false
	}
	if len(this.ClusterIDs) != len(that1.ClusterIDs) {
		return false
	}
	for i := range this.ClusterIDs {
		if !this.ClusterIDs[i].Equal(that1.ClusterIDs[i]) {
			return false
		}
	}
	if this.Configs != that1.Configs {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	if this.Enabled != that1.Enabled {
		return false
	}
	if this.FrequencyS != that1.FrequencyS {
		return false
	}
	return true
}
func (this *GetScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptRequest)
	if !ok {
		that2, ok := that.(GetScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *GetScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptResponse)
	if !ok {
		that2, ok := that.(GetScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Script.Equal(that1.Script) {
		return false
	}
	return true
}
func (this *GetScriptsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptsRequest)
	if !ok {
		that2, ok := that.(GetScriptsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.IDs) != len(that1.IDs) {
		return false
	}
	for i := range this.IDs {
		if !this.IDs[i].Equal(that1.IDs[i]) {
			return false
		}
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *GetScriptsResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetScriptsResponse)
	if !ok {
		that2, ok := that.(GetScriptsResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Scripts) != len(that1.Scripts) {
		return false
	}
	for i := range this.Scripts {
		if !this.Scripts[i].Equal(that1.Scripts[i]) {
			return false
		}
	}
	return true
}
func (this *CreateScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateScriptRequest)
	if !ok {
		that2, ok := that.(CreateScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Script != that1.Script {
		return false
	}
	if this.CronExpr != that1.CronExpr {
		return false
	}
	if len(this.ClusterIDs) != len(that1.ClusterIDs) {
		return false
	}
	for i := range this.ClusterIDs {
		if !this.ClusterIDs[i].Equal(that1.ClusterIDs[i]) {
			return false
		}
	}
	if this.Configs != that1.Configs {
		return false
	}
	if this.Token != that1.Token {
		return false
	}
	if this.FrequencyS != that1.FrequencyS {
		return false
	}
	if this.Disabled != that1.Disabled {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *CreateScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateScriptResponse)
	if !ok {
		that2, ok := that.(CreateScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	return true
}
func (this *UpdateScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateScriptRequest)
	if !ok {
		that2, ok := that.(UpdateScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Script.Equal(that1.Script) {
		return false
	}
	if !this.CronExpression.Equal(that1.CronExpression) {
		return false
	}
	if !this.ClusterIDs.Equal(that1.ClusterIDs) {
		return false
	}
	if !this.Configs.Equal(that1.Configs) {
		return false
	}
	if !this.Enabled.Equal(that1.Enabled) {
		return false
	}
	if !this.FrequencyS.Equal(that1.FrequencyS) {
		return false
	}
	if !this.ScriptId.Equal(that1.ScriptId) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *ClusterIDs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ClusterIDs)
	if !ok {
		that2, ok := that.(ClusterIDs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Value) != len(that1.Value) {
		return false
	}
	for i := range this.Value {
		if !this.Value[i].Equal(that1.Value[i]) {
			return false
		}
	}
	return true
}
func (this *UpdateScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateScriptResponse)
	if !ok {
		that2, ok := that.(UpdateScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *DeleteScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeleteScriptRequest)
	if !ok {
		that2, ok := that.(DeleteScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *DeleteScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeleteScriptResponse)
	if !ok {
		that2, ok := that.(DeleteScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *CronScript) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&cronscriptpb.CronScript{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "Script: "+fmt.Sprintf("%#v", this.Script)+",\n")
	s = append(s, "CronExpr: "+fmt.Sprintf("%#v", this.CronExpr)+",\n")
	if this.ClusterIDs != nil {
		s = append(s, "ClusterIDs: "+fmt.Sprintf("%#v", this.ClusterIDs)+",\n")
	}
	s = append(s, "Configs: "+fmt.Sprintf("%#v", this.Configs)+",\n")
	s = append(s, "Token: "+fmt.Sprintf("%#v", this.Token)+",\n")
	s = append(s, "Enabled: "+fmt.Sprintf("%#v", this.Enabled)+",\n")
	s = append(s, "FrequencyS: "+fmt.Sprintf("%#v", this.FrequencyS)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cronscriptpb.GetScriptRequest{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cronscriptpb.GetScriptResponse{")
	if this.Script != nil {
		s = append(s, "Script: "+fmt.Sprintf("%#v", this.Script)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptsRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cronscriptpb.GetScriptsRequest{")
	if this.IDs != nil {
		s = append(s, "IDs: "+fmt.Sprintf("%#v", this.IDs)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetScriptsResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cronscriptpb.GetScriptsResponse{")
	if this.Scripts != nil {
		s = append(s, "Scripts: "+fmt.Sprintf("%#v", this.Scripts)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CreateScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&cronscriptpb.CreateScriptRequest{")
	s = append(s, "Script: "+fmt.Sprintf("%#v", this.Script)+",\n")
	s = append(s, "CronExpr: "+fmt.Sprintf("%#v", this.CronExpr)+",\n")
	if this.ClusterIDs != nil {
		s = append(s, "ClusterIDs: "+fmt.Sprintf("%#v", this.ClusterIDs)+",\n")
	}
	s = append(s, "Configs: "+fmt.Sprintf("%#v", this.Configs)+",\n")
	s = append(s, "Token: "+fmt.Sprintf("%#v", this.Token)+",\n")
	s = append(s, "FrequencyS: "+fmt.Sprintf("%#v", this.FrequencyS)+",\n")
	s = append(s, "Disabled: "+fmt.Sprintf("%#v", this.Disabled)+",\n")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CreateScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cronscriptpb.CreateScriptResponse{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UpdateScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&cronscriptpb.UpdateScriptRequest{")
	if this.Script != nil {
		s = append(s, "Script: "+fmt.Sprintf("%#v", this.Script)+",\n")
	}
	if this.CronExpression != nil {
		s = append(s, "CronExpression: "+fmt.Sprintf("%#v", this.CronExpression)+",\n")
	}
	if this.ClusterIDs != nil {
		s = append(s, "ClusterIDs: "+fmt.Sprintf("%#v", this.ClusterIDs)+",\n")
	}
	if this.Configs != nil {
		s = append(s, "Configs: "+fmt.Sprintf("%#v", this.Configs)+",\n")
	}
	if this.Enabled != nil {
		s = append(s, "Enabled: "+fmt.Sprintf("%#v", this.Enabled)+",\n")
	}
	if this.FrequencyS != nil {
		s = append(s, "FrequencyS: "+fmt.Sprintf("%#v", this.FrequencyS)+",\n")
	}
	if this.ScriptId != nil {
		s = append(s, "ScriptId: "+fmt.Sprintf("%#v", this.ScriptId)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ClusterIDs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cronscriptpb.ClusterIDs{")
	if this.Value != nil {
		s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UpdateScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&cronscriptpb.UpdateScriptResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeleteScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cronscriptpb.DeleteScriptRequest{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeleteScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&cronscriptpb.DeleteScriptResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringService(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CronScriptServiceClient is the client API for CronScriptService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CronScriptServiceClient interface {
	GetScript(ctx context.Context, in *GetScriptRequest, opts ...grpc.CallOption) (*GetScriptResponse, error)
	GetScripts(ctx context.Context, in *GetScriptsRequest, opts ...grpc.CallOption) (*GetScriptsResponse, error)
	CreateScript(ctx context.Context, in *CreateScriptRequest, opts ...grpc.CallOption) (*CreateScriptResponse, error)
	UpdateScript(ctx context.Context, in *UpdateScriptRequest, opts ...grpc.CallOption) (*UpdateScriptResponse, error)
	DeleteScript(ctx context.Context, in *DeleteScriptRequest, opts ...grpc.CallOption) (*DeleteScriptResponse, error)
}

type cronScriptServiceClient struct {
	cc *grpc.ClientConn
}

func NewCronScriptServiceClient(cc *grpc.ClientConn) CronScriptServiceClient {
	return &cronScriptServiceClient{cc}
}

func (c *cronScriptServiceClient) GetScript(ctx context.Context, in *GetScriptRequest, opts ...grpc.CallOption) (*GetScriptResponse, error) {
	out := new(GetScriptResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.CronScriptService/GetScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptServiceClient) GetScripts(ctx context.Context, in *GetScriptsRequest, opts ...grpc.CallOption) (*GetScriptsResponse, error) {
	out := new(GetScriptsResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.CronScriptService/GetScripts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptServiceClient) CreateScript(ctx context.Context, in *CreateScriptRequest, opts ...grpc.CallOption) (*CreateScriptResponse, error) {
	out := new(CreateScriptResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.CronScriptService/CreateScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptServiceClient) UpdateScript(ctx context.Context, in *UpdateScriptRequest, opts ...grpc.CallOption) (*UpdateScriptResponse, error) {
	out := new(UpdateScriptResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.CronScriptService/UpdateScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronScriptServiceClient) DeleteScript(ctx context.Context, in *DeleteScriptRequest, opts ...grpc.CallOption) (*DeleteScriptResponse, error) {
	out := new(DeleteScriptResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.CronScriptService/DeleteScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CronScriptServiceServer is the server API for CronScriptService service.
type CronScriptServiceServer interface {
	GetScript(context.Context, *GetScriptRequest) (*GetScriptResponse, error)
	GetScripts(context.Context, *GetScriptsRequest) (*GetScriptsResponse, error)
	CreateScript(context.Context, *CreateScriptRequest) (*CreateScriptResponse, error)
	UpdateScript(context.Context, *UpdateScriptRequest) (*UpdateScriptResponse, error)
	DeleteScript(context.Context, *DeleteScriptRequest) (*DeleteScriptResponse, error)
}

// UnimplementedCronScriptServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCronScriptServiceServer struct {
}

func (*UnimplementedCronScriptServiceServer) GetScript(ctx context.Context, req *GetScriptRequest) (*GetScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetScript not implemented")
}
func (*UnimplementedCronScriptServiceServer) GetScripts(ctx context.Context, req *GetScriptsRequest) (*GetScriptsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetScripts not implemented")
}
func (*UnimplementedCronScriptServiceServer) CreateScript(ctx context.Context, req *CreateScriptRequest) (*CreateScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateScript not implemented")
}
func (*UnimplementedCronScriptServiceServer) UpdateScript(ctx context.Context, req *UpdateScriptRequest) (*UpdateScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateScript not implemented")
}
func (*UnimplementedCronScriptServiceServer) DeleteScript(ctx context.Context, req *DeleteScriptRequest) (*DeleteScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteScript not implemented")
}

func RegisterCronScriptServiceServer(s *grpc.Server, srv CronScriptServiceServer) {
	s.RegisterService(&_CronScriptService_serviceDesc, srv)
}

func _CronScriptService_GetScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptServiceServer).GetScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.CronScriptService/GetScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptServiceServer).GetScript(ctx, req.(*GetScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptService_GetScripts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetScriptsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptServiceServer).GetScripts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.CronScriptService/GetScripts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptServiceServer).GetScripts(ctx, req.(*GetScriptsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptService_CreateScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptServiceServer).CreateScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.CronScriptService/CreateScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptServiceServer).CreateScript(ctx, req.(*CreateScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptService_UpdateScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptServiceServer).UpdateScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.CronScriptService/UpdateScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptServiceServer).UpdateScript(ctx, req.(*UpdateScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronScriptService_DeleteScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronScriptServiceServer).DeleteScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.CronScriptService/DeleteScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronScriptServiceServer).DeleteScript(ctx, req.(*DeleteScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CronScriptService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.services.internal.CronScriptService",
	HandlerType: (*CronScriptServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetScript",
			Handler:    _CronScriptService_GetScript_Handler,
		},
		{
			MethodName: "GetScripts",
			Handler:    _CronScriptService_GetScripts_Handler,
		},
		{
			MethodName: "CreateScript",
			Handler:    _CronScriptService_CreateScript_Handler,
		},
		{
			MethodName: "UpdateScript",
			Handler:    _CronScriptService_UpdateScript_Handler,
		},
		{
			MethodName: "DeleteScript",
			Handler:    _CronScriptService_DeleteScript_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/cloud/cron_script/cronscriptpb/service.proto",
}

func (m *CronScript) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CronScript) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CronScript) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FrequencyS != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.FrequencyS))
		i--
		dAtA[i] = 0x48
	}
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintService(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Configs) > 0 {
		i -= len(m.Configs)
		copy(dAtA[i:], m.Configs)
		i = encodeVarintService(dAtA, i, uint64(len(m.Configs)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.ClusterIDs) > 0 {
		for iNdEx := len(m.ClusterIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ClusterIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.CronExpr) > 0 {
		i -= len(m.CronExpr)
		copy(dAtA[i:], m.CronExpr)
		i = encodeVarintService(dAtA, i, uint64(len(m.CronExpr)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Script) > 0 {
		i -= len(m.Script)
		copy(dAtA[i:], m.Script)
		i = encodeVarintService(dAtA, i, uint64(len(m.Script)))
		i--
		dAtA[i] = 0x1a
	}
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Script != nil {
		{
			size, err := m.Script.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetScriptsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.IDs) > 0 {
		for iNdEx := len(m.IDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.IDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetScriptsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetScriptsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetScriptsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for iNdEx := len(m.Scripts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Scripts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CreateScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Disabled {
		i--
		if m.Disabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.FrequencyS != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.FrequencyS))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintService(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Configs) > 0 {
		i -= len(m.Configs)
		copy(dAtA[i:], m.Configs)
		i = encodeVarintService(dAtA, i, uint64(len(m.Configs)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ClusterIDs) > 0 {
		for iNdEx := len(m.ClusterIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ClusterIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.CronExpr) > 0 {
		i -= len(m.CronExpr)
		copy(dAtA[i:], m.CronExpr)
		i = encodeVarintService(dAtA, i, uint64(len(m.CronExpr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Script) > 0 {
		i -= len(m.Script)
		copy(dAtA[i:], m.Script)
		i = encodeVarintService(dAtA, i, uint64(len(m.Script)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.ScriptId != nil {
		{
			size, err := m.ScriptId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.FrequencyS != nil {
		{
			size, err := m.FrequencyS.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Enabled != nil {
		{
			size, err := m.Enabled.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Configs != nil {
		{
			size, err := m.Configs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ClusterIDs != nil {
		{
			size, err := m.ClusterIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.CronExpression != nil {
		{
			size, err := m.CronExpression.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Script != nil {
		{
			size, err := m.Script.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ClusterIDs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ClusterIDs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Value[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *UpdateScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DeleteScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	offset -= sovService(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CronScript) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Script)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.CronExpr)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.ClusterIDs) > 0 {
		for _, e := range m.ClusterIDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	l = len(m.Configs)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.Enabled {
		n += 2
	}
	if m.FrequencyS != 0 {
		n += 1 + sovService(uint64(m.FrequencyS))
	}
	return n
}

func (m *GetScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Script != nil {
		l = m.Script.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetScriptsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.IDs) > 0 {
		for _, e := range m.IDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetScriptsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Scripts) > 0 {
		for _, e := range m.Scripts {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *CreateScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Script)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.CronExpr)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.ClusterIDs) > 0 {
		for _, e := range m.ClusterIDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	l = len(m.Configs)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.FrequencyS != 0 {
		n += 1 + sovService(uint64(m.FrequencyS))
	}
	if m.Disabled {
		n += 2
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *CreateScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *UpdateScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Script != nil {
		l = m.Script.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.CronExpression != nil {
		l = m.CronExpression.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.ClusterIDs != nil {
		l = m.ClusterIDs.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Configs != nil {
		l = m.Configs.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Enabled != nil {
		l = m.Enabled.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.FrequencyS != nil {
		l = m.FrequencyS.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.ScriptId != nil {
		l = m.ScriptId.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ClusterIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Value) > 0 {
		for _, e := range m.Value {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *UpdateScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DeleteScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *DeleteScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovService(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *CronScript) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForClusterIDs := "[]*UUID{"
	for _, f := range this.ClusterIDs {
		repeatedStringForClusterIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForClusterIDs += "}"
	s := strings.Join([]string{`&CronScript{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Script:` + fmt.Sprintf("%v", this.Script) + `,`,
		`CronExpr:` + fmt.Sprintf("%v", this.CronExpr) + `,`,
		`ClusterIDs:` + repeatedStringForClusterIDs + `,`,
		`Configs:` + fmt.Sprintf("%v", this.Configs) + `,`,
		`Token:` + fmt.Sprintf("%v", this.Token) + `,`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`FrequencyS:` + fmt.Sprintf("%v", this.FrequencyS) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetScriptRequest{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetScriptResponse{`,
		`Script:` + strings.Replace(this.Script.String(), "CronScript", "CronScript", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptsRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForIDs := "[]*UUID{"
	for _, f := range this.IDs {
		repeatedStringForIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForIDs += "}"
	s := strings.Join([]string{`&GetScriptsRequest{`,
		`IDs:` + repeatedStringForIDs + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetScriptsResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForScripts := "[]*CronScript{"
	for _, f := range this.Scripts {
		repeatedStringForScripts += strings.Replace(f.String(), "CronScript", "CronScript", 1) + ","
	}
	repeatedStringForScripts += "}"
	s := strings.Join([]string{`&GetScriptsResponse{`,
		`Scripts:` + repeatedStringForScripts + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForClusterIDs := "[]*UUID{"
	for _, f := range this.ClusterIDs {
		repeatedStringForClusterIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForClusterIDs += "}"
	s := strings.Join([]string{`&CreateScriptRequest{`,
		`Script:` + fmt.Sprintf("%v", this.Script) + `,`,
		`CronExpr:` + fmt.Sprintf("%v", this.CronExpr) + `,`,
		`ClusterIDs:` + repeatedStringForClusterIDs + `,`,
		`Configs:` + fmt.Sprintf("%v", this.Configs) + `,`,
		`Token:` + fmt.Sprintf("%v", this.Token) + `,`,
		`FrequencyS:` + fmt.Sprintf("%v", this.FrequencyS) + `,`,
		`Disabled:` + fmt.Sprintf("%v", this.Disabled) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateScriptResponse{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateScriptRequest{`,
		`Script:` + strings.Replace(fmt.Sprintf("%v", this.Script), "StringValue", "types.StringValue", 1) + `,`,
		`CronExpression:` + strings.Replace(fmt.Sprintf("%v", this.CronExpression), "StringValue", "types.StringValue", 1) + `,`,
		`ClusterIDs:` + strings.Replace(this.ClusterIDs.String(), "ClusterIDs", "ClusterIDs", 1) + `,`,
		`Configs:` + strings.Replace(fmt.Sprintf("%v", this.Configs), "StringValue", "types.StringValue", 1) + `,`,
		`Enabled:` + strings.Replace(fmt.Sprintf("%v", this.Enabled), "BoolValue", "types.BoolValue", 1) + `,`,
		`FrequencyS:` + strings.Replace(fmt.Sprintf("%v", this.FrequencyS), "Int64Value", "types.Int64Value", 1) + `,`,
		`ScriptId:` + strings.Replace(fmt.Sprintf("%v", this.ScriptId), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterIDs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForValue := "[]*UUID{"
	for _, f := range this.Value {
		repeatedStringForValue += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForValue += "}"
	s := strings.Join([]string{`&ClusterIDs{`,
		`Value:` + repeatedStringForValue + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateScriptResponse{`,
		`}`,
	}, "")
	return s
}
func (this *DeleteScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteScriptRequest{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteScriptResponse{`,
		`}`,
	}, "")
	return s
}
func valueToStringService(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *CronScript) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CronScript: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CronScript: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Script", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Script = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CronExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterIDs = append(m.ClusterIDs, &uuidpb.UUID{})
			if err := m.ClusterIDs[len(m.ClusterIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Configs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyS", wireType)
			}
			m.FrequencyS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FrequencyS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Script", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Script == nil {
				m.Script = &CronScript{}
			}
			if err := m.Script.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IDs = append(m.IDs, &uuidpb.UUID{})
			if err := m.IDs[len(m.IDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetScriptsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetScriptsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetScriptsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scripts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Scripts = append(m.Scripts, &CronScript{})
			if err := m.Scripts[len(m.Scripts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Script", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Script = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CronExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterIDs = append(m.ClusterIDs, &uuidpb.UUID{})
			if err := m.ClusterIDs[len(m.ClusterIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Configs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyS", wireType)
			}
			m.FrequencyS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FrequencyS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Disabled = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Script", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Script == nil {
				m.Script = &types.StringValue{}
			}
			if err := m.Script.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronExpression", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CronExpression == nil {
				m.CronExpression = &types.StringValue{}
			}
			if err := m.CronExpression.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClusterIDs == nil {
				m.ClusterIDs = &ClusterIDs{}
			}
			if err := m.ClusterIDs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Configs == nil {
				m.Configs = &types.StringValue{}
			}
			if err := m.Configs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Enabled == nil {
				m.Enabled = &types.BoolValue{}
			}
			if err := m.Enabled.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FrequencyS == nil {
				m.FrequencyS = &types.Int64Value{}
			}
			if err := m.FrequencyS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScriptId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScriptId == nil {
				m.ScriptId = &uuidpb.UUID{}
			}
			if err := m.ScriptId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClusterIDs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ClusterIDs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterIDs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value, &uuidpb.UUID{})
			if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipService(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowService
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthService
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupService
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthService
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthService        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
)
